package cn.unknowpupil.init.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created at 2021/3/25 by w10g <br>
 * Initialize ThreadTest ... <br>
 *
 * @author unknowpupil
 * @since 0.0.1
 */
public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.err.println("---------开始------");
        /**  七大参数
         *  int corePoolSize,
         *  核心线程数[一直存在除非设置了allowCoreThreadTimeOut]  线程池创建好以后就准备就绪的线程数量，就等待来接收异步任务去在执行
         *     corePoolSize 设置 5 就相当于 有5个 Thread thread = new Thread();   但是没执行， 如果线程放进去了之后就会产生 thread.start()运行
         *
         *  int maximumPoolSize,
         *   最大线程数 控制资源
         *   maximumPoolSize 200 就算100万个异步任务，我也只有200个线程去处理
         *
         *  long keepAliveTime,
         *   存活时间，如果当前的线程数量大于核心数量 。
         *   会释放空闲的线程只要空闲大于制定的存活时间
         *   核心线程数是一直存在的
         *   那么释放的是（maximumPoolSize-corePoolSize）
         *
         *  TimeUnit unit,
         *   keepAliveTime 时间是多久 单位是啥  TimeUnit这个就是设置时间单位
         *
         *
         *  BlockingQueue<Runnable> workQueue,  这个是压力测试吞吐量的峰值
         *  阻塞队列 。 如果任务有很多 最大只允许200 那么其他的线程就会放在队列里面，
         *  只要有线程空闲，就去队列里面取出新的任务继续执行
         *
         *  ThreadFactory threadFactory, 使用默认的就好  The {@link Executors#defaultThreadFactory}
         *   默认的 线程创建线程的工程，如何 new Thread()的
         *  RejectedExecutionHandler handler
         *   如果队列满了，按照指定的拒绝策略，拒绝执行任务
         *  默认使用 这种构造器  private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
         *
         *   工作顺序
         *   1 线程池创建，准备好核心线程数，准备接收任务
         *   2 core满了，就把将要进来的任务放入阻塞队列中，空闲的核心线程就会自己去阻塞队列回去任务执行。
         *   3 如果阻塞队列满了，就直接开启新线程在执行，最大只能开max指定的数量
         *   4 max 满了就用RejectedExecutionHandler拒绝任务
         *   5 max都执行完了，有很多空闲，就在指定keepAliveTime时间内是让(max-core)这些线程。
         *  注意：LinkedBlockingDeque
         */
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
                200,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(10000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
//          Executors.newCachedThreadPool(); core 为0 所有都可回收
//          Executors.newFixedThreadPool(); 固定大小 core=max 都不可回收
//          Executors.newScheduledThreadPool(); 定时任务的线程池
//          Executors.newSingleThreadExecutor(); 单线程的线程池，后台从队列伦理获取任务一个一个执行

        System.err.println("---------结束------ ");


    }


    public static class ThreadDemo03 implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            System.out.println("当前线程：" + Thread.currentThread().getName());
            int i = 10 / 5;
            Thread.sleep(100);
            System.out.println("运行结果");
            return i;
        }
    }

    public static class ThreadDemo02 implements Runnable {
        @Override
        public void run() {
            System.out.println("当前线程：" + Thread.currentThread().getName());
            int i = 10 / 5;
            System.out.println("运行结果");
        }
    }

    public static class ThreadDemo01 extends Thread {
        @Override
        public void run() {
            System.out.println("当前线程：" + Thread.currentThread().getName());
            int i = 10 / 5;
            System.out.println("运行结果");
        }
    }


}
